// #include <iostream>
// #include <memory>
// // 简单工厂模式
// // 水果类
// class Fruits
// {
// public:
//     Fruits(){}; // 构造函数
//     // 创建生产方式的纯虚函数
//     virtual void show() = 0;
// };
// // 水果的产品
// class Apple : public Fruits
// {
// public:
//     Apple(){};
//     virtual void show()
//     {
//         std::cout << "我是一个红苹果" << std::endl;
//     };
// };
// class Banana : public Fruits
// {
// public:
//     Banana(){};
//     virtual void show()
//     {
//         std::cout << "我是一个黄香蕉" << std::endl;
//     };
// };

// // 给我们使用的水果工厂
// class FritisFactory
// {
// public:
//     // 创建水果的方法
//     static std::shared_ptr<Fruits> create(const std::string &name)
//     {
//         if (name == "苹果")
//             return std::make_shared<Apple>();
//         else
//             return std::make_shared<Banana>();
//     }
// };

// int
// main()
// {
//     std::shared_ptr<Fruits> fruit = FritisFactory::create("苹果"); // 工厂生产苹果
//     fruit->show();                                                 // 显示苹果
//     fruit = FritisFactory::create("香蕉");                         // 工厂生产香蕉
//     fruit->show();                                                 // 显示香蕉
//     return 0;
// }

// #include <iostream>
// #include <memory>
// // 工厂方法模式
// // 水果类
// class Fruits
// {
// public:
//     Fruits(){}; // 构造函数
//     // 创建生产方式的纯虚函数
//     virtual void show() = 0;
// };
// // 水果的产品
// class Apple : public Fruits
// {
// public:
//     Apple(){};
//     virtual void show()
//     {
//         std::cout << "我是一个红苹果" << std::endl;
//     };
// };
// class Banana : public Fruits
// {
// public:
//     Banana(){};
//     virtual void show()
//     {
//         std::cout << "我是一个黄香蕉" << std::endl;
//     };
// };

// // 给我们使用的水果工厂
// class FritisFactory
// {
// public:
//     // 创建水果的纯虚函数
//     virtual std::shared_ptr<Fruits> create() = 0;
// };

// // 苹果工厂
// class AppleFactory
// {
// public:
//     std::shared_ptr<Fruits> create() override // 用来重写基类的同名虚函数
//     {
//         return std::make_ptr<Apple>();
//     }
// };
// // 香蕉工厂
// class BananFactory
// {
// public:
//     std::shared_ptr<Fruits> create() override // 用来重写基类的同名虚函数
//     {
//         return std::make_ptr<Banana>();
//     }
// };

// int main()
// {
//     std::shared_ptr<FritisFactory> ff(new AppleFactory()); // 创建一个苹果工厂
//     std::shared_ptr<Fruits> fruit = ff->create();          // 生产苹果
//     fruit->show();
//     ff.reset(new BananFactory()); // 重新管理工厂为香蕉工厂
//     fruit = ff->create();         // 创建一个香蕉
//     fruit->show();                // 生产香蕉
//     return 0;
// }

#include <iostream>
#include <memory>
// 抽象工厂模式
// 水果类
class Fruits
{
public:
    Fruits(){}; // 构造函数
    // 创建生产方式的纯虚函数
    virtual void show() = 0;
};
// 水果的产品
class Apple : public Fruits
{
public:
    Apple(){};
    virtual void show()
    {
        std::cout << "我是一个红苹果" << std::endl;
    };
};
class Banana : public Fruits
{
public:
    Banana(){};
    virtual void show()
    {
        std::cout << "我是一个黄香蕉" << std::endl;
    };
};

// 动物类
class Animal
{
public:
    Animal(){}; // 构造函数
    // 创建生产方式的纯虚函数
    virtual void name1() = 0;
};
// 动物的产品
class Lamp : public Animal
{
public:
    Lamp(){};
    virtual void name1()
    {
        std::cout << "我是一只山羊" << std::endl;
    };
};
class Dog : public Animal
{
public:
    Dog(){};
    virtual void name1()
    {
        std::cout << "我是一只狗" << std::endl;
    };
};

// 给我们使用的抽象工厂
class Factory
{
public:
    // 创建分类的纯虚函数
    virtual std::shared_ptr<Fruits> getFruits(const std::string &name) = 0;
    virtual std::shared_ptr<Animal> getAnimal(const std::string &name) = 0;
};

// 水果工厂
class FruitFactory : public Factory
{
public:
    virtual std::shared_ptr<Animal> getAnimal(const std::string &name)
    {
        return std::shared_ptr<Animal>(); // 返回一个空对象
    }
    virtual std::shared_ptr<Fruits> getFruits(const std::string &name)
    {
        if (name == "苹果")
            return std::make_shared<Apple>();
        else if (name == "香蕉")
            return std::make_shared<Banana>();
        else
            return std::shared_ptr<Fruits>(); // 否则为空
    }
};
// 动物工厂
class AnimalFactory : public Factory
{
public:
    virtual std::shared_ptr<Fruits> getFruits(const std::string &name)
    {
        return std::shared_ptr<Fruits>(); // 返回一个空对象
    }
    virtual std::shared_ptr<Animal> getAnimal(const std::string &name)
    {
        if (name == "小羊")
            return std::make_shared<Lamp>();
        else if (name == "小狗")
            return std::make_shared<Dog>();
        else
            return std::shared_ptr<Animal>(); // 否则为空
    }
};

// 超级工厂
class FactoryProducer
{
public:
    static std::shared_ptr<Factory> getFactory(const std::string &name)
    {
        if (name == "动物")
        {
            return std::make_shared<AnimalFactory>();
        }
        else
        {
            return std::make_shared<FruitFactory>();
        }
    }
};

int main()
{
    std::shared_ptr<Factory> fruit_factory = FactoryProducer::getFactory("⽔果");
    std::shared_ptr<Fruits> fruit = fruit_factory->getFruits("苹果");
    fruit->show();
    fruit = fruit_factory->getFruits("香蕉");
    if (fruit == nullptr)
    {
        return 0;
    }
    fruit->show();
    std::shared_ptr<Factory> animal_factory = FactoryProducer::getFactory("动物");
    std::shared_ptr<Animal> animal = animal_factory->getAnimal("小羊");
    animal->name1();
    animal = animal_factory->getAnimal("小狗");
    if (animal == nullptr)
    {
        return 0;
    }
    animal->name1();
    return 0;
}